/*Proxy
The Proxy design pattern is a design pattern lets you provide a surrogate
or placeholder object for another object to control access to it.
For example imagine you want to give students access to a
library but you don't want them to be able to access the library directly.
First you need to make a library class:
*/
class Library {
public getBooks() {
console.log('Getting books...');
}
}
// Then you make a proxy class that will give students access to the library:
class LibraryProxy {
constructor(private library: Library) {}
public getBooks() {
this.library.getBooks();
}
}
// Then you make your library:
const library = new LibraryProxy(new Library());
library.getBooks();
/*Facade
The Facade pattern is a design pattern lets you define a simple unified interface
to a large body of code .
imagine you want to make a car and you want to make it with a engine,
transmission, and wheels.
First you need to make a car class:
*/
class Car {
public makeCar() {
console.log('Making a car...');
}
}
// Then you make a facade class that will make the car with an engine, transmission, and wheels and abstract the process from the user
class CarFacade {
constructor(private car: Car) {}
public makeCar() {
this.car.makeCar();
this.makeEngine();
this.makeTransmission();
this.makeWheels();
}
private makeEngine() {
console.log('Making engine...');
}
private makeTransmission() {
console.log('Making transmission...');
}
private makeWheels() {
console.log('Making wheels...');
}
}
// Then you make your car:
const car = new CarFacade(new Car());
car.makeCar();